package com.ego.dubbo.service.impl;

import com.ego.commons.exception.DaoException;
import com.ego.dubbo.service.TbContentCategoryDubboService;
import com.ego.mapper.TbContentCategoryMapper;
import com.ego.pojo.TbContentCategory;
import com.ego.pojo.TbContentCategoryExample;
import org.apache.dubbo.config.annotation.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;


/**
 * 查询内容分类表
 */
@Service
public class TbContentCategoryDubboServiceImpl implements TbContentCategoryDubboService {
    @Autowired
    private TbContentCategoryMapper tbContentCategoryMapper;
    @Override
    public List<TbContentCategory> selectByPid(long pid) {

        TbContentCategoryExample example = new TbContentCategoryExample();
        //  查询时所有被删除的分类不在进行查询。查询结果需要进行排序。
        example.createCriteria().andStatusEqualTo(1).andParentIdEqualTo(pid);
        //排序
        example.setOrderByClause("sort_order asc");
        return tbContentCategoryMapper.selectByExample(example);
    }

    /**
     * 添加新类目
     * @param category
     * @return
     * @throws DaoException
     */
    @Override
    @Transactional
    public int insert(TbContentCategory category) throws DaoException {

        TbContentCategoryExample example = new TbContentCategoryExample();
        example.createCriteria().andNameEqualTo(category.getName()).andStatusEqualTo(1);;
        List<TbContentCategory> list = tbContentCategoryMapper.selectByExample(example);
        // 说明没有重复名称
        if(list.size()==0){
            int index = tbContentCategoryMapper.insert(category);
            if(index==1){
                // 判断父类目is_parent是否为true
                TbContentCategory parentCategory = tbContentCategoryMapper.selectByPrimaryKey(category.getParentId());
                if(!parentCategory.getIsParent()){
                    TbContentCategory parentUpdated = new TbContentCategory();
                    parentUpdated.setId(parentCategory.getId());
                    parentUpdated.setIsParent(true);
                    parentUpdated.setUpdated(category.getCreated());
                    int indexParent = tbContentCategoryMapper.updateByPrimaryKeySelective(parentUpdated);
                    if(indexParent!=1){
                        throw new DaoException("新增类目-修改父节点失败");
                    }
                }
                return 1;
            }
        }
        throw new DaoException("新增类目失败");
    }

    /*
    如果方法中出现多条DML操作，需要进行事务控制。添加@Transactional，抛出异常等。
    如果方法中只有一条DML，认为只要不出现异常同时返回结果正确就可以。
     */
    @Override
    public int updateNameById(TbContentCategory tbContentCategory) {
        TbContentCategoryExample example = new TbContentCategoryExample();

        example.createCriteria().andNameEqualTo(tbContentCategory.getName()).andStatusEqualTo(1);
        //查询  是否有一样名字的  状态是正常的
        List<TbContentCategory> list = tbContentCategoryMapper.selectByExample(example);

        // 说明没有重复名称
        if (list.size()==0){
            return tbContentCategoryMapper.updateByPrimaryKeySelective(tbContentCategory);
        }
        return 0;
    }

    @Override
    @Transactional
    public int deleteById(Long id) throws DaoException {
        Date date = new Date();
        TbContentCategory category = new TbContentCategory();
        category.setId(id);
        category.setUpdated(date);
        category.setStatus(2);
        // 当前分类逻辑删除功能  只修改状态
        int i = tbContentCategoryMapper.updateByPrimaryKeySelective(category);
        if (i==1){

            // 查询当前节点信息
            TbContentCategory currContentCategory  = tbContentCategoryMapper.selectByPrimaryKey(id);

            TbContentCategoryExample example  = new TbContentCategoryExample();
            //查询到  父节点下面的子节点  example  相当于 select  ...  where
            // 判断当前节点的父节点是否还有其他正常状态的子节点。
            example.createCriteria().andParentIdEqualTo(currContentCategory.getParentId()).andStatusEqualTo(1);
            List<TbContentCategory> list  = tbContentCategoryMapper.selectByExample(example);

            // 父分类已经没有正常状态的子节点，修改is_parent为false
            if (list!=null&&list.size()==0){
                TbContentCategory parent = new TbContentCategory();
                parent.setIsParent(false);
                parent.setId(currContentCategory.getParentId());
                parent.setUpdated(date);

                int i1 = tbContentCategoryMapper.updateByPrimaryKeySelective(parent);
                if (i1!=1){
                    throw new DaoException("删除分类 - 修改父分类失败");
                }
            }
            //判断当前节点是否是 父节点 如果是 那么进行  递归删除
            if (currContentCategory.getIsParent()){

                //调用 递归方法

                deleteChildrenById(id,date);
            }
            return 1;
        }
        throw new DaoException("删除分类 - 失败");
    }

    /**
     * 递归
     * @param id 父id
     * @param date 更新时间
     * @throws DaoException
     */
    private void deleteChildrenById(long id,Date date) throws  DaoException{
        TbContentCategoryExample example = new TbContentCategoryExample();
        //where  ParentId=id  查询父节点下的 子节点
        example.createCriteria().andParentIdEqualTo(id);

        //查到子节点集合
        List<TbContentCategory> list  = tbContentCategoryMapper.selectByExample(example);
        //遍历删除
        for (TbContentCategory category  : list) {
//            创建新的对象  方便  修改  其他字段不用设值
            TbContentCategory updateCategory = new TbContentCategory();
            updateCategory.setId(category.getId());
            updateCategory.setStatus(2);
            updateCategory.setUpdated(date);
            int i = tbContentCategoryMapper.updateByPrimaryKeySelective(updateCategory);
            if (i==1){
                // 如果是父节点才继续进行修改子节点
                if (category.getIsParent()){
                    //开始递归 调用自己
                    deleteChildrenById(category.getId(),date);
                }
            }else {

                //修改失败
                throw new DaoException("删除分类 - 更新分类状态失败");
            }
        }

    }
}
